NewVertexAIProvider writes credentials JSON to a temp file and sets GOOGLE_APPLICATION_CREDENTIALS globally, but never removes the temp file nor restores the prior env var. This can leak service-account credentials on disk and introduces cross-request races when multiple providers are created concurrently in the same process. Prefer passing credentials to the underlying client/plugin without mutating process env; if that’s not possible, guard the env var change with a mutex, restore the previous value, and ensure the temp file is deleted when no longer needed (including on error paths).

The factory functions build modelName as "<provider>/" + model without applying the prior defaulting behavior (e.g., OpenAI default model, Anthropic default model). Since module and DB schemas allow model to be empty (default ''), this can produce invalid model names like openai/ and fail at runtime. Consider preserving existing defaults inside these factories when model is empty to maintain backward compatibility.

Module provider creation also uses context.Background() for Genkit provider factories. This prevents module users from passing cancellation/deadline semantics into any initialization work performed by the Genkit plugins. Prefer using a context associated with the module lifecycle (or at minimum TODO/option to supply one) rather than hard-coding context.Background().

Tool request conversion currently sets ToolCall.ID and ToolCall.Name both to part.ToolRequest.Name. This loses any per-call identifier and makes multiple tool calls to the same tool indistinguishable (and tool results will all reuse the same ToolCallID). If Genkit provides a distinct call ID, map it into ToolCall.ID and keep the tool name in ToolCall.Name; otherwise generate a stable unique ID per tool request and ensure the corresponding tool result messages map back correctly.

resolveToolRefs defines tools via gk.DefineTool using an input map[string]any handler, but it doesn’t incorporate provider.ToolDef.Parameters (JSON Schema). As a result, the model may not receive the expected parameter schema for tool calling, which can break or degrade tool-call generation. Consider defining tools with an explicit schema (or using a typed input struct) so tool parameters are communicated accurately to Genkit/underlying providers.

Tool-call identity is not preserved across turns: assistant tool requests are created with ToolRequest.Name=tc.Name (tc.ID is discarded), but tool results are encoded as ToolResponse.Name=m.ToolCallID. Since ToolCallID is later set to tc.ID (currently generated UUIDs), the tool response won't match the original tool request, breaking multi-turn tool calling. Align the identifier used in ToolRequest/ToolResponse (and preserve the provider.ToolCall.ID across conversions) so tool results can be correlated to the right request.

When an assistant message includes ToolCalls, the text Content is dropped entirely (only ToolRequest parts are emitted). The executor records assistant Content alongside ToolCalls, so dropping it changes the conversation history and can affect model behavior. Preserve any non-empty assistant Content by emitting a text part in addition to tool-request parts (matching the behavior of the previous provider conversions).

Tool results are always wrapped as {result: <string>}. In this codebase, executor tool results are typically JSON-encoded strings (or error strings), so double-wrapping can distort the intended structure presented to the model. Consider attempting to JSON-decode Message.Content first (use the decoded value as ToolResponse.Output when valid), and only fall back to a string wrapper when decoding fails.

Stream() emits tool_call events from chunks (via fromGenkitChunk) and then emits tool_call events again at Done by converting the final response. Because tool-call IDs are generated during conversion, the Done-phase tool_call IDs won't match earlier tool_call events and can also cause duplicate execution downstream. Prefer emitting tool_call events from a single source (either incremental chunks or final response) and ensure IDs are stable across the stream.

The default model constants differ from the previous provider implementations (e.g., Anthropic default was claude-sonnet-4-20250514, Gemini default was gemini-2.0-flash). This changes runtime behavior for configs that omit Model. If the goal is a drop-in replacement, keep defaults aligned with the old providers (or document the behavior change explicitly).

The default baseURL for copilot_models is set to https://models.inference.ai.azure.com, but the model-listing path (provider.ListModels) defaults copilot_models to https://models.github.ai/inference. These should match; otherwise copilot_models will point at a different endpoint depending on which code path is used. Update the default baseURL here to the intended GitHub Models endpoint (or adjust both places consistently).

Provider initialization uses context.TODO() because ModuleFactory doesn’t receive a context. This prevents cancellation/timeouts during provider setup and can hang module loading if initialization blocks (e.g., auth discovery). Prefer threading a real context from module Start()/wiring, or at minimum use context.Background() and document the expected lifecycle/timeout behavior.

llama_cpp is wired through NewOpenAICompatibleProvider with BaseURL passed through unchanged. If cfg.BaseURL is empty, the provider will be initialized without a usable endpoint. Add a default base URL for llama_cpp when none is provided (matching previous llama.cpp provider defaults) or return a validation error early.

These ProviderRegistry factories pass user-configured BaseURL values into Genkit providers without validating them. The repo has SSRF protections via provider.ValidateBaseURL (https-only + blocks private/internal IPs) used in other code paths. Apply the same validation here for remote providers (e.g., anthropic/openai/openrouter/copilot) before creating the provider, and return an error when invalid.

The post-create cache re-check avoids overwriting the cache entry, but it still allows multiple goroutines to concurrently create a provider on cold start (all but one instance are discarded). If provider creation is expensive (Genkit init, auth discovery), consider using a per-alias singleflight (or store a promise/future in the cache) so only one initialization runs per alias.